home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / escalant / escala21.lha / escalante2.1 / src / gm / PVGraphElement.C < prev    next >
C/C++ Source or Header  |  1993-07-15  |  22KB  |  1,159 lines
  1. //
  2. //    Copyright (C) 1993  Jeff McWhirter
  3. //
  4. //$PVGraphElement$
  5. #include "PVGraphElement.h"
  6. #include "PVRelation.h"
  7.  
  8.  
  9. #include "Class.h"
  10.  
  11. #include "String.h"
  12. #include "Set.h"
  13.  
  14.  
  15.  
  16. #include "ClassManager.h"
  17.  
  18.  
  19.  
  20.  
  21.  
  22. #ifdef USEGROUP
  23. NewMetaImpl(PVGraphElement,PVGraphElement_BASE,(TP(protos),TP(InRels),TP(OutRels) ,T(eventMask),TP(name),TP(groups),0));
  24. #endif
  25.  
  26.  
  27. #ifndef USEGROUP
  28. NewMetaImpl(PVGraphElement,PVGraphElement_BASE,(TP(protos),TP(InRels),TP(OutRels) ,T(eventMask),TP(name),0));
  29. #endif
  30.  
  31. #define PVGraphElement_BASE GraphObject
  32.  
  33. ObjList * gVProtoList=0;
  34.  
  35.  
  36.  
  37. bool VInDie = FALSE;
  38. static Set DefaultVDieSet;
  39. Set  * CurrentVDieSet =0;
  40.  
  41. void SetCurrentVDieSet(Set * s){
  42.     CurrentVDieSet =s;
  43. }
  44.  
  45. void StartVDie(){VInDie = TRUE;}
  46. void EndVDie(){
  47.     VInDie = FALSE;
  48.     KillVGraphElements();
  49. }
  50.  
  51.  
  52.  
  53.  
  54.  
  55. void InVDie(bool f){VInDie = f;}
  56.  
  57. static Set GlobalVGraphElementSet;
  58. static Set * CurrentVGraphElementSet;
  59.  
  60.  
  61.  
  62. void SetCurrentVGraphElementSet(Set *s){
  63.     CurrentVGraphElementSet =s;
  64. }
  65.  
  66. Set * GetVGraphElementSet(){
  67.     return (CurrentVGraphElementSet?
  68.             CurrentVGraphElementSet:
  69.             &GlobalVGraphElementSet);
  70. }
  71.  
  72.  
  73. bool gVSetIO = TRUE;
  74.  
  75. void WriteOutVSet(OStream & o){
  76.  
  77. Object * obj;
  78. int cnt =0;
  79. Iter next(GetVGraphElementSet());
  80. while (obj = next())
  81.     if(((PVGraphElement*)obj)->OkToWriteOut())
  82.         cnt ++;
  83.  
  84.  
  85. o << cnt SP;
  86. next.Reset(GetVGraphElementSet());
  87. while (obj = next())
  88.     if(((PVGraphElement*)obj)->OkToWriteOut())
  89.         o << obj SP;
  90.  
  91. }
  92.  
  93.  
  94. bool gVReadingIn = FALSE;
  95.  
  96. void ReadInVSet(IStream & o){
  97. gVReadingIn = TRUE;
  98. int cnt;
  99. o >> cnt;
  100. GetVGraphElementSet()->Empty(cnt);
  101. Object * obj;
  102. for(int i=0; i< cnt;i++){
  103.     o >> obj;
  104.     if(obj) 
  105.         GetVGraphElementSet()->Add(obj);
  106. }
  107. gVReadingIn = FALSE;
  108. }
  109.  
  110.  
  111. Set * GetVDieSet(){return  (CurrentVDieSet?CurrentVDieSet:&DefaultVDieSet);}
  112.  
  113.  
  114.  
  115.  
  116.  
  117. PVGraphElement::PVGraphElement(){
  118. GetVGraphElementSet()->Add(this);
  119. SetAdding(FALSE);
  120. IfFalseDontWriteOutOriginal(TRUE);
  121. IfFalseDontWriteOutClone(TRUE);
  122.  
  123. InRels= new ObjList();
  124. OutRels= new ObjList();
  125. eventMask = 0;
  126. name = 0;
  127. affectedByEvents=0;
  128. protos =0;
  129.  
  130.  
  131. #ifdef USEGROUP
  132. groups =0;
  133. #endif    
  134.  
  135.  
  136. }
  137.  
  138. #ifdef USEGROUP
  139. VGroup * PVGraphElement::GetGroupWithId(int i){
  140. if(!groups)return 0;
  141. Iter next(groups);
  142. VGroup*g;
  143. while(g = (VGroup*)next())
  144.     if(g->GetId() == i) return g;
  145. return 0;
  146. }
  147. #endif
  148.  
  149. void PVGraphElement::InitClone(){
  150. INeedPtr(this);
  151. PVGraphElement_BASE::InitClone();
  152. IfFalseDontWriteOutOriginal(TRUE);
  153. GetVGraphElementSet()->Add(this);
  154. SetDead(FALSE);
  155.  
  156. InRels= new ObjList();
  157. OutRels= new ObjList();
  158.  
  159. eventMask = 0;
  160. affectedByEvents=0;
  161.  
  162. #ifdef USEGROUP
  163. if(groups){
  164.     ObjList * oldg = groups;
  165.     groups = new ObjList();
  166.     Iter next(oldg);
  167.     VGroup * g;
  168.     while(g = (VGroup*) next())
  169.         AddGroup((VGroup*)EscalanteClone(g));
  170. }
  171. #endif
  172. }
  173.  
  174. void PVGraphElement::AddGroupRelation(PVRelation * r){
  175.     PropagateEvent(eAEventAddElement,this,(void*)r);
  176. }
  177.  
  178.  
  179.  
  180.  
  181.  
  182.  
  183. void * PVGraphElement::DoEvent2(Events event, PVGraphElement * elt, void * data, ObjList * list)
  184. {
  185. if(DoneEvent(event))     return 0;
  186.  
  187. bool mylist = FALSE;
  188. ObjList l;
  189. if(list == 0) list = GetEventList(event);
  190. if(list == 0){
  191.     mylist= TRUE;
  192.      list = &l;
  193.     SetEventList(event,list);
  194. }
  195.  
  196. if(list){
  197.     if(list->ContainsPtr((Object*)this)) 
  198.         return 0;
  199.     list->Add((Object*)this);
  200. }
  201. SetEvent(event);
  202. DoEvent(event,elt,data);
  203. ClearEvent(event);
  204. if(mylist) ClearEventList(event);
  205. return 0;
  206. }
  207.  
  208.  
  209. void  * PVGraphElement::DoEvent(Events event,PVGraphElement * ,  void * data){
  210. switch(event){
  211.  case eAEventDie: Die();    break;
  212.  case eAEventDieHint:         if(gDoDieHints) Die();     break;
  213.  case eAEventCopyHint:         if(gDoCopyHints) return (void*)Copy();     
  214.  case eAEventCopy:         return (void*)Copy();     
  215.  case eAEventAddElement:    AddElement((PVGraphElement * )data);     break;
  216.  default: break;
  217. }
  218. return 0;
  219. }    
  220.  
  221.  
  222.  
  223.  
  224. void * PVGraphElement::GetAttribute(int aid,DataType & type){
  225. if(aid == ATTRID(PVGraphElement,name)){
  226.     type = eChar;
  227.     return (void*)name;
  228. }
  229.  
  230. return PVGraphElement_BASE::GetAttribute(aid,type); 
  231. }
  232.  
  233.  
  234.  
  235. void PVGraphElement::ChangeAttribute(int aid, void * data, DataType type){
  236. if(aid == ATTRID(PVGraphElement,name)){
  237.     char * n=0;
  238.     if(ChangeData(data,type,n))
  239.         SetName(n);
  240.  
  241. } 
  242. else PVGraphElement_BASE::ChangeAttribute(aid,data,type);
  243. }
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250. void PVGraphElement::SendAttributeChange(int aid, void * data,DataType type){
  251. PVGraphElement_BASE::SendAttributeChange( aid, data, type);
  252. if(SendingAttrChange()) return;
  253. SendingAttrChange(TRUE);
  254.  
  255.  
  256. PVRelation * r;
  257. if(gDoFromHdAttrMap && InRels){
  258. Iter next(InRels);
  259. while( r = (PVRelation*) next()) {
  260.     if(!r->IsDead())
  261.         r->AttrChangeOnHd(aid,  data, type);
  262. }
  263.  
  264. }
  265.  
  266.  
  267.  
  268. if(gDoFromHdAttrMap && OutRels){
  269. Iter next(OutRels);
  270. while( r = (PVRelation*) next()) {
  271.     if(!r->IsDead())
  272.         r->AttrChangeOnTl(aid,  data, type);
  273. }
  274. }
  275.  
  276. SendingAttrChange(FALSE);
  277. }
  278.  
  279.  
  280.  
  281.  
  282.  
  283. void * PVGraphElement::PropagateEvent(Events event,Events notevents,  PVGraphElement * e,void * data, ObjList * list){
  284.  
  285. if(!OkToPropagateEvent(event))
  286.     return 0;
  287.  
  288. //if(DoneEvent(event)) return 0;
  289. bool mylist = FALSE;
  290. ObjList l;
  291. if(list == 0) list = GetEventList(event);
  292. if(list == 0){
  293.     mylist= TRUE;
  294.      list = &l;
  295.     SetEventList(event,list);
  296. }
  297.  
  298. if(e == 0)     e = this;
  299. list->Add((Object*)this);
  300. SetEvent(event);
  301. void * rv = PropagateEvent2(event, notevents,e,data, list);
  302. ClearEvent(event);
  303. if(mylist) ClearEventList(event);
  304. return rv;
  305. }
  306.  
  307.  
  308.  
  309.  
  310.  
  311. void * PVGraphElement::PropagateEvent2(Events event,Events notevents,  PVGraphElement * e,void * data, ObjList * list){
  312.  
  313. PVRelation * r;
  314. if(InRels){
  315. Iter next(InRels);
  316. while(r = (PVRelation *)next())
  317.     r->EventOccurenceOnHd(event,notevents,e,data,list);
  318. }
  319.  
  320.  
  321. if(OutRels){
  322.     Iter next(OutRels);
  323.     while(r = (PVRelation *)next())
  324.         r->EventOccurenceOnTl(event,notevents,e,data,list);
  325. }
  326.  
  327. return 0;
  328. }
  329.  
  330.  
  331.  
  332. PVGraphElement* PVGraphElement::Copy(){
  333. if(Copied() || HaveIBeenCloned(this)) return 0;
  334. bool iamfirst = StartCloning();
  335. Copied(TRUE);
  336. PVGraphElement * clone = (PVGraphElement*)EscalanteClone(this);
  337. if(!clone) return 0;
  338. clone->Copied(FALSE);
  339.  
  340. if(gDoCopyHints)
  341.     PropagateEvent((Events)(eAEventCopy|eAEventCopyHint),this);
  342. else 
  343.     PropagateEvent(eAEventCopy,this);
  344.  
  345. Copied(FALSE);
  346. if(iamfirst) EndCloning();
  347. return clone;
  348. }
  349.  
  350.  
  351.  
  352. void PVGraphElement::SetDead(bool f){
  353.     if(f && !IsDead()) GetVDieSet()->Add((Object*)this);
  354.     else if(!f && IsDead())  GetVDieSet()->Remove((Object*)this);
  355.     PVGraphElement_BASE::SetDead(f);
  356. }
  357.  
  358.  
  359. void PVGraphElement::Die(){
  360. if(IsDead()) return;
  361. PVGraphElement_BASE::Die();
  362.  
  363.  
  364. Send(0,eAEventDie,0);
  365.  
  366. if(gDoDieHints)
  367.     PropagateEvent((Events)(eAEventDie|eAEventDieHint),this);
  368. else
  369.     PropagateEvent(eAEventDie,this);
  370.  
  371.  
  372. MS_Die();
  373.  
  374. }
  375.  
  376.  
  377.  
  378.  
  379.  
  380.  
  381.  
  382. PVGraphElement::~PVGraphElement(){
  383.  
  384. #ifdef USEGROUP
  385. if(groups) groups->FreeAll();
  386. SafeDelete(groups);
  387. #endif
  388.  
  389. if(!IsDead()) Die(); 
  390. GetVGraphElementSet()->Remove(this);
  391. GetVDieSet()->Remove(this);
  392.  
  393.  
  394. if(InRels){
  395.     InRels-> ForEach(PVRelation,SetHead)(0);
  396. }
  397. if(OutRels){
  398.     OutRels->ForEach(PVRelation,SetTail)(0);
  399. }
  400.  
  401. SafeDelete( InRels);
  402. SafeDelete( OutRels);
  403. }
  404.  
  405.  
  406.  
  407. PVGraphElement * PVGraphElement::GetPrototypeOfClass(class Class * c)
  408. {
  409. if(!protos) return 0;
  410. Iter next(protos);
  411. PVGraphElement * e;
  412. PVGraphElement * close=0;
  413.  
  414. while(e = (PVGraphElement*) next())
  415. {
  416.     if(e->IsA()->IsEqual(c))return e;
  417.     if(e->IsA()->isKindOf(c)) close = e;
  418. }
  419. return close;
  420. }
  421.  
  422.  
  423.  
  424. OStream& PVGraphElement::PrintOn(OStream& s){
  425. PVGraphElement_BASE::PrintOn(s);
  426. if(!gVSetIO){
  427.     s << InRels SP;
  428.     s << OutRels SP;
  429. }
  430.  
  431. s << protos SP;
  432. s << affectedByEvents SP;
  433. #ifdef USEGROUP
  434. s << groups SP;
  435. #endif
  436. s.PrintString(name);
  437. s SP;
  438. return s;
  439. }
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446. IStream& PVGraphElement::ReadFrom(IStream& s){
  447. PVGraphElement_BASE::ReadFrom(s);
  448. GetVGraphElementSet()->Add(this);
  449. if(!gVSetIO){
  450.     s >> InRels ;
  451.     s >> OutRels ;
  452. }
  453. else {
  454.     InRels = new ObjList();
  455.     OutRels = new ObjList();
  456. }
  457. s >> protos;
  458. s >> affectedByEvents ;
  459.  
  460. #ifdef USEGROUP
  461. s >> groups ;
  462. #endif
  463.  
  464. s.ReadString(&name);
  465. eventMask =0;
  466. return s;
  467. }
  468.  
  469.  
  470.  
  471. void PVGraphElement::AddInRelation(PVRelation *r){
  472. if(!r) return;
  473. if(!InRels) InRels = new ObjList();
  474. InRels->Add((Object*)r);
  475.  
  476. #ifdef USEGROUP
  477. if(!gVReadingIn && groups){//These brackets have to be here.
  478.     groups-> ForEach(VGroup,AddedInRelation)(r);    
  479. }
  480. #endif
  481. }
  482.  
  483. void PVGraphElement::RemoveInRelation(PVRelation *r){
  484. if(!InRels) return;
  485. InRels->RemovePtr((Object*)r);
  486.  
  487. #ifdef USEGROUP
  488. if(groups){//These brackets have to be here.
  489.     groups-> ForEach(VGroup,RemovedInRelation)(r);    
  490. }
  491. #endif
  492.  
  493. }
  494.  
  495. void PVGraphElement::AddOutRelation(PVRelation *r)
  496. {
  497. if(!r) return;
  498. if(!OutRels) OutRels = new  ObjList();
  499. OutRels->Add((Object*)r);
  500.  
  501. #ifdef USEGROUP
  502. if(!gVReadingIn && groups){//These brackets have to be here.
  503.     groups-> ForEach(VGroup,AddedOutRelation)(r);    
  504. }
  505. #endif
  506.  
  507. }
  508.  
  509. void PVGraphElement::RemoveOutRelation(PVRelation *r)
  510. {
  511. if(!OutRels) return;
  512. OutRels->RemovePtr((Object*)r);
  513.  
  514. #ifdef USEGROUP
  515. if(groups){//These brackets have to be here.
  516.     groups-> ForEach(VGroup,RemovedOutRelation)(r);    
  517. }
  518. #endif
  519.  
  520. }
  521.  
  522. void PVGraphElement::NewTail(PVRelation * r, PVGraphElement * elt,PVGraphElement* oldtl){
  523.  
  524. #ifdef USEGROUP
  525. if(groups){//These brackets have to be here.
  526.     groups-> ForEach(VGroup,NewTail)(r,elt,oldtl);    
  527. }
  528. #endif
  529.  
  530. }
  531. void PVGraphElement::NewHead(PVRelation * r, PVGraphElement * elt,PVGraphElement* oldhd){
  532.  
  533. #ifdef USEGROUP
  534. if(groups){
  535.     groups-> ForEach(VGroup,NewHead)(r,elt,oldhd);    
  536. }
  537. #endif
  538.  
  539. }
  540.  
  541.  
  542.  
  543.  
  544. void PVGraphElement::GetRelsWithDep(ObjList & l, Events events, DepTypes type,RDir dir){
  545. ObjList * rlist = GetRelations(dir);
  546. if(!rlist) return;
  547. Iter next(rlist);
  548. register PVRelation *r ;
  549. while(r = (PVRelation*)next())
  550.     if(r->GetEventDep(events,type)) l.Add((Object*)r);
  551. }
  552.  
  553.  
  554.  
  555. PVRelation * PVGraphElement::GetRelation(PVGraphElement * e,    RDir dir, Class * c,bool isk){
  556. if(c == 0) c = Meta(PVRelation);
  557.  
  558. ObjList * rlist = GetRelations(dir);
  559. if(!rlist) return 0;
  560.  
  561. Iter next(rlist);
  562. PVRelation *r ;
  563. PVGraphElement * other;
  564. while(r = (PVRelation*)next()) {
  565.     if((other = r->GetOtherElement(this)) &&  other==e){
  566.         if(isk){
  567.             if( r->IsA()->isKindOf(c))
  568.                 return(r);
  569.         }
  570.         else if(r->IsA()->IsEqual(c))
  571.             return r;
  572.     }
  573. }
  574. return 0;
  575. }
  576.  
  577.  
  578.  
  579.  
  580.  
  581.  
  582. bool PVGraphElement::PFunc(  VPropFunc func ,
  583.             void * funcdata , 
  584.             int maxhops , 
  585.             RDir dir, 
  586.             VPathFunc path ,
  587.             void * pathdata,
  588.             ObjList * l,
  589.             int hopssofar
  590.              ){
  591.  
  592. if(Propagating() || hopssofar >= maxhops) return TRUE;
  593. if(l && l->ContainsPtr(this)) return TRUE;
  594. ObjList myl;
  595. if(!l) l = &myl;
  596. hopssofar ++;
  597.  
  598.  
  599.     
  600. Propagating(TRUE);
  601. register PVRelation * r;
  602. register PVGraphElement  * elt;
  603. bool OkToContinue = TRUE;
  604. bool ok = TRUE;
  605. register PVGraphElement * root = (PVGraphElement*)this;
  606. if((dir == eIn || dir == eInOut) && InRels){
  607.     Iter next(InRels);
  608.     while(r = (PVRelation*) next()){
  609.         elt = (PVGraphElement*)r->tl;
  610.         if(!path ||  path(root,r,elt,pathdata,hopssofar))
  611.             ok = func(root,r,elt,funcdata,hopssofar,OkToContinue);
  612.         if(!OkToContinue ) {Propagating(FALSE);return FALSE;}
  613.         if(ok && elt && hopssofar < maxhops)  
  614.             if(!elt->PFunc(func,funcdata,maxhops,dir,path, pathdata,l,hopssofar))
  615.                 {Propagating(FALSE);return FALSE;}
  616.  
  617.     }
  618. }
  619.  
  620.  
  621. if((dir == eOut || dir == eInOut) && OutRels){
  622.     Iter next(OutRels);
  623.     while(r = (PVRelation*) next()){
  624.         elt = (PVGraphElement*)r->hd;
  625.         if(!path ||  path(root,r,elt,pathdata,hopssofar))
  626.             ok = func(root,r,elt,funcdata,hopssofar,OkToContinue);
  627.         if(!OkToContinue ) {Propagating(FALSE);return FALSE;}
  628.         if(ok && elt && hopssofar <= maxhops) 
  629.             if(! elt->PFunc(func,funcdata,maxhops,dir,path, pathdata,l,hopssofar)) 
  630.                 {Propagating(FALSE);return FALSE;}
  631.  
  632.     }
  633. }
  634. Propagating(FALSE);
  635. return TRUE;
  636. }
  637.  
  638.  
  639.  
  640.  
  641. bool ClassPath(PVGraphElement*, PVRelation* rel, PVGraphElement* target, void * data, int  ){
  642. if(!data) return TRUE;
  643. TwoClassStruct *s = (TwoClassStruct*)data;
  644. if(s->c1 && rel)
  645.     if(!rel->IsA()->isKindOf(s->c1))  return FALSE;
  646.  
  647. if(s->c2 && target)
  648.     if(!target->IsA()->isKindOf(s->c2))  return FALSE;
  649.  
  650. return TRUE;
  651.  
  652. }
  653.  
  654. bool PVGraphElement::PFunc(VPropFunc func ,
  655.             void * funcdata , 
  656.             Class* relc ,
  657.             Class*eltc,
  658.             int hops, 
  659.             RDir dir){
  660.  
  661.         TwoClassStruct s;
  662.         s.c1 = relc;
  663.         s.c2 = eltc;
  664.         bool result = PFunc(func,funcdata,hops,dir,ClassPath,(void*)&s);
  665.         return result;
  666. }
  667.     
  668.  
  669.  
  670. void KillVGraphElements(){
  671.     PVGraphElement * o;
  672.     Iter next(GetVDieSet());
  673.     while(o = (PVGraphElement*)next()) {
  674.         GetVDieSet()->Remove(o);
  675.         if(o->IsDead())
  676.             SafeDelete(o);
  677.     }
  678. }
  679.  
  680.  
  681.  
  682. PVRelation * PVGraphElement::GetDefaultRelation(PVGraphElement * tl,PVGraphElement * hd,Class * relclass)
  683. {
  684. PVGraphElement * phd, * ptl;
  685. PVRelation * prel;
  686. PVRelation *isaisk=0,*iskisk = 0;
  687.  
  688. if(relclass == 0) relclass = Meta(PVRelation);
  689.  
  690.  
  691. ObjList dummy;
  692. Iter next(&dummy);
  693.  
  694. ObjList * plist=0;
  695. for(int  cnt = 0; cnt < 2; cnt++){
  696. if(cnt ==  0) plist = protos;
  697. else {
  698.     if(protos !=  gVProtoList)
  699.          plist = gVProtoList;
  700.     else plist =0;
  701. }
  702.  
  703. if(plist){
  704.     next.Reset(plist);
  705.     while(prel = (PVRelation*)next()){
  706.         if( prel->IsA()->isKindOf(relclass)){
  707.             phd = prel->GetHead();
  708.             ptl = prel->GetTail();
  709.             if(phd && ptl){
  710.                 if((hd && phd ->IsA()->IsEqual(hd->IsA())) || ! hd){
  711.                     if((tl && ptl ->IsA()->IsEqual(tl->IsA()) ) || ! tl)
  712.                         return (PVRelation*)EscalanteClone(prel); 
  713.                     if((tl && tl ->IsA()->isKindOf(ptl->IsA()) ) || ! tl)
  714.                         isaisk = prel;
  715.                 }
  716.                 if((hd && hd ->IsA()->isKindOf(phd->IsA())) || ! hd) {
  717.                     if((tl && ptl ->IsA()->IsEqual(tl->IsA()) ) || ! tl)
  718.                         isaisk = prel;
  719.                     else if((tl && tl ->IsA()->isKindOf(ptl->IsA()) ) || ! tl)
  720.                         iskisk = prel;
  721.                 }
  722.             }
  723.         }
  724.     }
  725. }    
  726. }
  727. if(isaisk) return (PVRelation*)EscalanteClone(isaisk); 
  728. else  if(iskisk) return (PVRelation*)EscalanteClone(iskisk); 
  729. else return 0;
  730. }
  731.  
  732. void PVGraphElement::AddElement(PVGraphElement * elt,PVRelation * rel){
  733.     if(elt == 0)     return;
  734.     if(!elt->AddOnCloning())return;
  735.     if(AddOnlyIfHaveProto()) {
  736.         bool haveone = FALSE;
  737.         PVGraphElement * pelt;
  738.         if(protos) {
  739.             Iter next(protos);
  740.             while((pelt=(PVGraphElement*)next()) && ! haveone)
  741.                 if(elt->IsA()->isKindOf(pelt->IsA()))
  742.                     haveone = TRUE;
  743.         }
  744.         if(gVProtoList && !haveone && gVProtoList != protos) {
  745.             Iter next(gVProtoList);
  746.             while((pelt=(PVGraphElement*)next()) && ! haveone)
  747.                 if(elt->IsA()->isKindOf(pelt->IsA()))
  748.                     haveone = TRUE;
  749.         }
  750.         if(!haveone) return;
  751.     }
  752.  
  753.  
  754.     if(!rel){
  755.  
  756.         rel =  GetDefaultRelation(this,elt);
  757.  
  758.         if(AddOnlyIfHaveDflt() && !rel) return;
  759.  
  760.     }
  761.  
  762.     if(!rel)    rel = GetDefaultMemberOf();
  763.  
  764.     if(rel){
  765.  
  766.         rel->SetTailHead(this,elt);
  767.  
  768.         PropagateEvent(eAEventAddElement,this,(void*)elt);
  769.     }
  770.  
  771. }
  772.  
  773. void PVGraphElement::AddElements(Set * list) {
  774.     if(!list) return;
  775.     Iter next(list);
  776.     PVGraphElement *e;
  777.     while(e = (PVGraphElement*)next()) AddElement(e);
  778. }
  779.  
  780.  
  781. void PVGraphElement::MoveRelation(PVRelation * r, RDir dir,bool tofront) {
  782. MovePtr((Object*)r,GetRelations(dir),tofront);
  783. }
  784.  
  785.  
  786.  
  787.  
  788.  
  789. void PVGraphElement::Pred( Class *relClass,  Class * eltClass, PVRelation*& retRel,PVGraphElement*&retElt,bool risk, bool eisk){
  790. if(!InRels) return;
  791. if(!relClass) relClass = Meta(PVRelation);
  792. if(!eltClass) eltClass = Meta(PVGraphElement);
  793. Iter next(InRels);
  794.  
  795. register  PVRelation * rel=0;
  796. register  PVGraphElement * elt=0;
  797. while(rel = (PVRelation*)next())
  798.     if(!rel->IsDead()){
  799.         if((risk && rel->IsA()->isKindOf(relClass)) || rel->IsA()->IsEqual(relClass))
  800.             if(elt = rel->GetTail())
  801.                 if((eisk && elt->IsA()->isKindOf(eltClass)) || elt->IsA()->IsEqual(eltClass)){
  802.                     retElt = elt; retRel = rel; return;
  803.                 }
  804.     }
  805. }
  806.  
  807.  
  808.  
  809. void PVGraphElement::Succ( Class *relClass,  Class * eltClass, PVRelation*&retRel,PVGraphElement*&retElt,bool risk, bool eisk){
  810. if(!OutRels) return;
  811. if(!relClass ) relClass = Meta(PVRelation);
  812. if(!eltClass ) eltClass = Meta(PVGraphElement);
  813. Iter next(OutRels);
  814.  
  815. register  PVRelation * rel;
  816. register  PVGraphElement * elt;
  817. while(rel = (PVRelation*)next())
  818.     if(!rel->IsDead()){
  819.         if((risk && rel->IsA()->isKindOf(relClass)) || rel->IsA()->IsEqual(relClass))
  820.             if(elt = rel->GetHead() )
  821.                 if((eisk &&elt->IsA()->isKindOf(eltClass)) || elt->IsA()->IsEqual(eltClass)){
  822.                     retElt = elt; retRel = rel; return;
  823.     }    
  824.     }
  825. }
  826.  
  827.  
  828.  
  829. PVGraphElement * PVGraphElement::Pred( Class *relClass,  Class * eltClass, bool risk, bool eisk){
  830. PVRelation * rel=0;
  831. PVGraphElement * elt=0;
  832. Pred(relClass,eltClass,rel,elt,risk,eisk);
  833. return elt;
  834. }
  835.  
  836.  
  837.  
  838. PVGraphElement * PVGraphElement::Succ(class Class *relClass, class Class * eltClass, bool risk, bool eisk){
  839. PVRelation * rel=0;
  840. PVGraphElement * elt=0;
  841. Succ(relClass,eltClass,rel,elt,risk,eisk);
  842. return elt;
  843. }
  844.  
  845.  
  846.  
  847.  
  848.  
  849. PVRelation * PVGraphElement::RelPred( Class *relClass,  Class * eltClass, bool risk, bool eisk){
  850. PVRelation * rel=0;
  851. PVGraphElement * elt=0;
  852. Pred(relClass,eltClass,rel,elt,risk,eisk);
  853. return rel;
  854. }
  855.  
  856.  
  857.  
  858. PVRelation * PVGraphElement::RelSucc(class Class *relClass, class Class * eltClass, bool risk, bool eisk){
  859. PVRelation * rel=0;
  860. PVGraphElement * elt=0;
  861. Succ(relClass,eltClass,rel,elt,risk,eisk);
  862. return rel;
  863. }
  864.  
  865.  
  866.  
  867.  
  868.  
  869.  
  870.  
  871.  
  872.  
  873.  
  874. #ifdef USEGROUP
  875.  
  876. NewMetaImpl(VOkToAdd,Object,(0));
  877. NewMetaImpl(VRelXElt,VOkToAdd,(0));
  878. NewMetaImpl(VGroup,Object,(TP(elts),0));
  879. NewMetaImpl(VRelGroup,VGroup,(0));
  880. NewMetaImpl(VEltGroup,VGroup,(0));
  881.  
  882. VGroup::~VGroup(){
  883. PVGraphElement  * prev =0;
  884. PVGraphElement  * next =0;
  885. PVRelation * tr;
  886. if(elts && firstProto){
  887.     next=(PVGraphElement*)elts->First();
  888.     prev = theelt;
  889.     if(prev && next){
  890.         tr=prev->GetRelation(next,eOut,firstProto->IsA(),FALSE); 
  891.             if(tr)    tr->Die();
  892.         }
  893. }
  894. if(elts&& relProto){
  895.     PVRelation * tr;
  896.     Iter iter(elts);
  897.     while(next = (PVGraphElement*)iter()){
  898.         next->RemoveObserver(this);
  899.         if(prev && next){
  900.             tr=prev->GetRelation(next,eOut,relProto->IsA(),FALSE); 
  901.             if(tr)
  902.                 tr->Die();
  903.         }
  904.         prev = next;
  905.     
  906.     }
  907. }
  908. SafeDelete(elts);
  909. }
  910.  
  911.  
  912. OStream& VGroup:: PrintOn(OStream&o){
  913. Object::PrintOn(o);
  914. o << id SP;
  915. o << relProto SP;
  916. o << firstProto SP;
  917. o << elts SP;
  918. o << criteria SP;
  919. return o;
  920. }
  921.  
  922.  
  923.  
  924. IStream& VGroup::ReadFrom(IStream&o){
  925. Object::ReadFrom(o);
  926. o >>  id;
  927. o >>  relProto;
  928. o >>  firstProto;
  929. o >>  elts;
  930. o >>  criteria;
  931. return o;
  932. }
  933.  
  934. IStream& VOkToAdd::ReadFrom(IStream&o){
  935. Object::ReadFrom(o);
  936. o >> Enum(dir) ;
  937. return o;
  938. }
  939.  
  940. OStream& VOkToAdd::PrintOn(OStream&o){
  941. Object::PrintOn(o);
  942. o << dir SP;
  943. return o;
  944. }
  945.  
  946.  
  947.  
  948. IStream& VRelXElt::ReadFrom(IStream&o){
  949. VOkToAdd::ReadFrom(o);
  950.  
  951. if(!gClassManager)gClassManager = new ClassManager();
  952.  
  953. char * rn = 0;
  954. char * en = 0;
  955. o.ReadString(&rn);
  956. o.ReadString(&en);
  957. if(rn) relc = gClassManager->Find(rn);
  958. if(en) eltc = gClassManager->Find(en);
  959. return o;
  960. }
  961.  
  962. OStream& VRelXElt::PrintOn(OStream&o){
  963. VOkToAdd::PrintOn(o);
  964.  
  965.  
  966. char * rn = relc?relc->Name():0;
  967. char * en = eltc?eltc->Name():0;
  968.  
  969. o.PrintString(rn);  o SP;
  970. o.PrintString(en);  o SP;
  971.  
  972. return o;
  973. }
  974.  
  975.  
  976.  
  977.  
  978.  
  979.  
  980. void VGroup::AddElement(PVGraphElement*elt){
  981.  
  982.     if(elts == 0) elts = new ObjList();
  983.     else if(elts->Contains(elt)) return;
  984.  
  985.     elt->AddObserver(this);
  986.     PVGraphElement * last = (PVGraphElement*)elts->Last();
  987.      elts->Add(elt);
  988.     if(last)
  989.         Connect(last,elt);
  990.  
  991.     else if(theelt && firstProto){
  992.         PVRelation * newrel = (PVRelation*) EscalanteClone(firstProto);
  993.         theelt->AddGroupRelation(newrel);
  994.         newrel->SetTailHead(theelt,elt);
  995.     }
  996. }
  997.  
  998. void VGroup::RemoveElement(PVGraphElement * elt){
  999.  
  1000. if(!elt || !elts) return;
  1001. if(!elts->Contains(elt)) return;
  1002. elt->RemoveObserver(this);
  1003.  
  1004.  
  1005. PVRelation *prev,*next,*tr,*first=0;
  1006.  
  1007.  
  1008. if( ((Object*)elt) == elts->First()  && theelt && firstProto){
  1009.     first=theelt->GetRelation(elt,eOut,firstProto->IsA(),FALSE); 
  1010. //    if(first) first->SetHead(0);
  1011. }
  1012.  
  1013.  
  1014.  
  1015.  
  1016. if(elts->Size() == 1) {
  1017.     elts->Remove(elt); 
  1018.     if(first) first->Die();
  1019.     return;
  1020. }
  1021.  
  1022. //Find the previous and the next elements
  1023. prev = (PVRelation*) elts->BeforePtr(elt);
  1024. next =  (PVRelation*)elts->AfterPtr(elt);
  1025. elts->Remove(elt);
  1026.  
  1027.  
  1028. if(prev && relProto){    
  1029.     tr=prev->GetRelation(elt,eOut,relProto->IsA(),FALSE); 
  1030.     if(tr) tr->Die();
  1031. }
  1032.  
  1033.  
  1034. if(next && relProto){    
  1035.     tr=elt->GetRelation(next,eOut,relProto->IsA(),FALSE);
  1036.     if(tr) tr->Die();
  1037. }
  1038.  
  1039. if(prev && next)    Connect(prev,next);
  1040.  
  1041. if(first && theelt && (prev = (PVRelation*)elts->First()))
  1042.     first->SetHead(prev);
  1043.  
  1044.     
  1045.  
  1046. }
  1047.  
  1048.  
  1049.  
  1050. void VRelGroup::AddedRelation(PVRelation * r,RDir dir){
  1051. if(!r) return;
  1052. if(criteria){
  1053.     if(dir == eOut){
  1054.         if(!criteria->OutRelationOk(r)) return;
  1055.     }
  1056.     else {
  1057.         if(!criteria->InRelationOk(r)) return;
  1058.     }
  1059. }
  1060. AddElement((PVGraphElement*)r);
  1061. }
  1062.  
  1063.  
  1064.  
  1065.  
  1066. void VEltGroup::RemovedInRelation(PVRelation * r){
  1067.     if(r)RemoveElement((PVGraphElement*)r->GetHead());
  1068. }
  1069. void VEltGroup::RemovedOutRelation(PVRelation * r){
  1070.     if(r)RemoveElement((PVGraphElement*)r->GetHead());
  1071. }
  1072.  
  1073. void VEltGroup::AddedInRelation(PVRelation * r){
  1074.     if(r) NewTail(r, r->GetTail(),0);
  1075. }
  1076.  
  1077. void VEltGroup::AddedOutRelation(PVRelation * r){
  1078.     if(r)NewHead(r,r->GetHead(),0);
  1079. }
  1080.  
  1081.  
  1082.  
  1083.  
  1084. void  VEltGroup::NewElt(RDir dir,PVRelation *r ,PVGraphElement* newelt,PVGraphElement* oldelt ){
  1085.     RemoveElement(oldelt);
  1086.     if(!newelt) return;
  1087.     if(criteria){
  1088.         if(dir == eOut){
  1089.             if(!criteria->HeadOk(newelt,r)) return;
  1090.         }
  1091.         else {
  1092.             if(!criteria->TailOk(newelt,r)) return;
  1093.         }
  1094.     }
  1095.     AddElement((PVGraphElement*)newelt);
  1096. }
  1097.  
  1098.  
  1099.  
  1100.  
  1101.  
  1102.  
  1103. void VGroup::Connect(PVGraphElement * e1,PVGraphElement * e2){
  1104. if(e1 && e2 && relProto){
  1105.     PVRelation * newrel = (PVRelation*) EscalanteClone(relProto);
  1106.     if(theelt) theelt->AddGroupRelation(newrel);
  1107.     newrel->SetTailHead(e1,e2);
  1108. }
  1109. }
  1110.  
  1111.  
  1112. void VGroup::DoObserve(int id, int part, void *d , Object *op){
  1113. if(part == eAEventDie && op && elts && elts->Contains(op))
  1114.     RemoveElement((PVGraphElement*)op);
  1115. else if(part == cPartSenderDied && op && elts && elts->Contains(op))
  1116.     elts->Remove(op);
  1117. else Object::DoObserve(id,part,d,op);
  1118. }
  1119.  
  1120. bool VRelXElt::HeadOk(PVGraphElement * hd,PVRelation * r){
  1121.     if(!hd) return FALSE;
  1122.     if(!OutRelationOk(r)) return FALSE;
  1123.     if(eltc) return hd->IsA()->isKindOf(eltc);
  1124.     return TRUE;
  1125.  
  1126. }
  1127.  
  1128. bool VRelXElt::TailOk(PVGraphElement * tl,PVRelation * r){
  1129.     if(!tl) return FALSE;
  1130.     if(!InRelationOk(r)) return FALSE;
  1131.     if(eltc) return tl->IsA()->isKindOf(eltc);
  1132.     return TRUE;
  1133. }
  1134.  
  1135.  
  1136. bool VRelXElt::InRelationOk(PVRelation * r){
  1137.     if(!r) return FALSE;
  1138.     if(!VOkToAdd::InRelationOk(r) ) return FALSE;
  1139.     if(relc) return r->IsA()->isKindOf(relc);
  1140.     else return TRUE;
  1141. }
  1142.  
  1143. bool VRelXElt::OutRelationOk(PVRelation * r){
  1144.     if(!r) return FALSE;
  1145.     if(!VOkToAdd::OutRelationOk(r) ) return FALSE;
  1146.     if(relc) return r->IsA()->isKindOf(relc);
  1147.     else return TRUE;
  1148. }
  1149.  
  1150.  
  1151.  
  1152.  
  1153.  
  1154. #endif USEGROUP
  1155.  
  1156.  
  1157.  
  1158.  
  1159.